// 前缀和
// 本质上是一个动态规划的思想，关键步骤如下：
// 1.确定状态表示
// 2.推导动态转移方程
// 3.初始化
// 4.确定填表顺序
// 5.确定返回值

// 例题 2：
// 描述
//        给你一个 n 行 m 列的矩阵 A ，下标从1开始。
//        接下来有 q 次查询，每次查询输入 4 个参数 x1 , y1 , x2 , y2
//        请输出以 (x1, y1) 为左上角 , (x2,y2) 为右下角的子矩阵的和，

//        输入描述：
//        第一行包含三个整数n,m,q.
//        接下来n行，每行m个整数，代表矩阵的元素
//        接下来q行，每行4个整数x1, y1, x2, y2，分别代表这次查询的参数
//
//        1 <= n, m <= 1000
//        1 ≤ q ≤ 105
//        -109 <= a[i][j] <= 109
//
//        1 ≤ x1 <= x2 <= n
//        1 <= y1 <= y2 <= m
//
//        输出描述：
//        输出q行，每行表示查询结果。
//        示例1
//        输入：
//        3 4 3
//        1 2 3 4
//        3 2 1 0
//        1 5 7 8
//        1 1 2 2
//        1 1 3 3
//        1 2 3 4
//        复制
//        输出：
//        8
//        25
//        32

// 解题思路：
// dp[i][j] 表示以 i,j 位置为结尾的矩阵所有元素的和
// dp[i][j] = dp[i - 1][j] + dp[i][j - 1] + a[i][j] - dp[i - 1][j - 1];
// ret = dp[x2][y2] - dp[x1 - 1][y2] - dp[x2][y1 - 1] + dp[x1 - 1][y1 - 1];

import java.util.Scanner;

public class Template2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        int m = in.nextInt();
        int q = in.nextInt();

        int[][] a = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                a[i][j] = in.nextInt();
            }
        }

        long[][] dp = new long[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1] + a[i][j] - dp[i - 1][j - 1];
            }
        }
        for(int k = 1; k <= q; k++){
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt();
            int y2 = in.nextInt();
            long ret = dp[x2][y2] - dp[x1 - 1][y2] - dp[x2][y1 - 1] + dp[x1 - 1][y1 - 1];
            System.out.println(ret);
        }
    }
}
